home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / x11 / strategy / xpat2-1.000 / xpat2-1 / xpat2-1.04 / src / r_Canfield.c < prev    next >
C/C++ Source or Header  |  1994-09-28  |  4KB  |  128 lines
  1. /*****************************************************************************/
  2. /*                                         */
  3. /*                                         */
  4. /*    X patience version 2 -- module r_Canfield.c                 */
  5. /*                                         */
  6. /*    Characteristics of the ``Canfield'' rules                 */
  7. /*    written by Michael Bischoff (mbi@mo.math.nat.tu-bs.de)             */
  8. /*    see COPYRIGHT.xpat2 for Copyright details                 */
  9. /*                                         */
  10. /*                                         */
  11. /*****************************************************************************/
  12. #include "xpatgame.h"
  13.  
  14.  
  15. static int baserank;
  16.  
  17. static int Canfield_valid(Cardindex srcind, Pileindex dstpile) {
  18.     int srcpile, dstcard, srccard;
  19.  
  20.     if (dstpile == VDECK-1)
  21.     return 0;    /* no move to the tmp */
  22.     srcpile = getpile(srcind);
  23.     if (srcpile == dstpile)
  24.     return 0;
  25.     if (game.piletype[srcpile] == Stack)
  26.     return 0;
  27.     dstcard = EMPTY(dstpile) ? -1 : game.cards[INDEX_OF_LAST_CARD(dstpile)];
  28.     srccard = game.cards[srcind];
  29.     switch (game.piletype[dstpile]) {
  30.     case Slot:    /* moves to Slot: depends on if slot is empty */
  31.     if (EMPTY(dstpile))
  32.         return srcpile == (VDECK-1) || (EMPTY(VDECK-1) && srcpile == VDECK);
  33.     /* dstpile not empty: rank and alternate colour! */
  34.         if (IS_JOKER(dstcard) || IS_JOKER(srccard))
  35.         ;
  36.     else {
  37.         if (RANK(srccard) != (12 + RANK(dstcard)) % 13)
  38.         return 0;
  39.         if (!DIFFERENT_COLOR(dstcard, srccard))
  40.         return 0;
  41.     }
  42.     if (game.piletype[srcpile] == Slot &&
  43.         srcind != INDEX_OF_FIRST_CARD(srcpile))
  44.         return 0;
  45.     return 1;
  46.     case Tmp:
  47.     case FaceupDeck:
  48.     case FacedownDeck:
  49.     return 0;    /* only implicit moves allowable */
  50.     case Stack:
  51.     if (srcind != INDEX_OF_LAST_CARD(srcpile))
  52.         return 0;    /* only one card at a time */
  53.     if (SUIT(srccard) != SUIT(dstpile))
  54.         return 0;
  55.     if (EMPTY(dstpile))
  56.         return RANK(srccard) == baserank;
  57.     return RANK(srccard) == (1 + RANK(dstcard)) % 13;
  58.     }
  59.     return 0;
  60. }
  61.  
  62. static void Canfield_newgame(void) {
  63.     int i;
  64.     int firstsuit;
  65.     /* specific part: one card on a stack, 3 on the talon (VDECK) */
  66.     firstsuit = SUIT(game.cards[0]);
  67.     baserank = RANK(game.cards[0]);
  68.  
  69.     for (i = 0; i <= firstsuit; ++i)
  70.     game.ind[i] = 0;
  71.     for (; i <= rules.numstacks; ++i)
  72.     game.ind[i] = 1;
  73.     for (; i <= rules.numstacks + rules.numslots; ++i)
  74.     game.ind[i] = 1 + i - rules.numstacks;
  75.     game.ind[LAST_SLOT+1] =  1 + rules.numslots;
  76.     game.ind[VDECK]       = 14 + rules.numslots; /* => 13 on the stock */
  77.     game.ind[IDECK]       = 17 + rules.numslots; /* =>  3 on the talon */
  78.     game.ind[IDECK+1]     = rules.numcards;
  79.     for (i = 0; i <= INDEX_OF_LAST_CARD(LAST_SLOT); ++i)
  80.     game.visible[i] = 1;
  81.     /* last card on stock and three cards on the talon */
  82.     for (i = game.ind[VDECK]-1; i < game.ind[VDECK]+3; ++i)
  83.     game.visible[i] = 1;
  84. }
  85.  
  86. static int Canfield_score(void) {
  87.     return -52 + 5 * (game.ind[rules.numstacks] - game.counter[1]);
  88. }
  89.  
  90. struct rules Canfield_rules = {
  91.     "Canfield",    /* shortname */
  92.     NULL,    /* longname */
  93.     NULL,       /* abbrev */
  94.     8,        /* layout_hints */
  95.     DECK_SOURCE|KLONDIKE_DEAL,/* variant */
  96.     0,        /* customizable */
  97.     0,        /* customized */
  98.     52,        /* numcards */
  99.     4,        /* numstacks */
  100.     4,        /* numslots */
  101.     1,        /* numtmps */
  102.     1,        /* numdecks */
  103.     13,        /* cards_per_color */
  104.     0,        /* numjokers */
  105.     {0, 999, 3, 0},/* param[0], param[1], param[2], param[3] */
  106.     0,        /* facedown */
  107.     1,        /* faceup */
  108.     0,        /* newgame_bits */
  109.     Canfield_newgame,/* new_game */
  110.     NULL,    /* game_won */
  111.     NULL,    /* new_cards */
  112.     ES_ALL|US_RA|MG_RA|ST_ONE|DC_ALWAYS, /* move_bits */
  113.     NULL,    /* deal_cards */
  114.     NULL,    /* undeal_cards */
  115.     NULL,    /* stackable */
  116.     Canfield_valid,    /* movevalid */
  117.     NULL,    /* valid */
  118.     NULL,    /* relaxed_valid */
  119.     NULL,    /* good_hint */
  120.     NULL,    /* automove */
  121.     Canfield_score,/* score */
  122.     208,    /* maxscore */
  123.     {0, TXTI_FLIP, 0, 0}, /* paramstring blocks */
  124.     0,        /* used */
  125.     NULL,    /* initfunc */
  126.     NULL,    /* local keyboard bindings */
  127. };
  128.